import * as fs from 'fs/promises';
import * as path from 'path';
import { FileManager } from './file-manager.js';

/**
 * 时序图生成指导类
 * 
 * 专门负责时序图的Mermaid到Draw.io转换指导。提供详细的转换规范、
 * 样式要求和XML结构指导，确保生成的时序图符合项目标准。
 * 
 * 核心功能：
 * 1. Mermaid语法分析 - 解析时序图的参与者、消息和交互
 * 2. 动态尺寸计算 - 根据复杂度自动计算合适的页面和元素尺寸
 * 3. 样式规范指导 - 提供基于0823版本的标准样式
 * 4. 版本管理 - 智能处理文件版本控制
 * 5. 特殊元素处理 - 自环消息、分组框、条件分支等
 */
export class SequenceGuide {
  private outputDir: string;
  private fileManager: FileManager;

  constructor() {
    // 使用绝对路径，确保在任何工作目录下都能正确找到输出目录
    // 检测是否在build目录中，如果是则向上两级，否则向上一级
    const currentDir = path.dirname(new URL(import.meta.url).pathname);
    const isBuildDir = currentDir.includes('/build') || currentDir.endsWith('/build');
    const projectRoot = isBuildDir 
      ? path.resolve(currentDir, '..') 
      : path.resolve(currentDir, '..');
    this.outputDir = path.join(projectRoot, 'drawio');
    this.fileManager = new FileManager();
  }

  async convertMermaidToDrawio(mermaidSyntax: string, diagramType: string, moduleName: string, description?: string): Promise<any> {
    try {
      // 确保输出目录存在
      await this.ensureOutputDirectory();
      
      // 智能版本管理：检测是否为重新生成
      const versionInfo = await this.determineVersion(moduleName, diagramType, description);
      
      // 生成文件名
      const timestamp = this.getCurrentDate();
      const mermaidFileName = `${moduleName}_${diagramType}_mermaid_${timestamp}.md`;
      const drawioFileName = `${moduleName}_${diagramType}_${versionInfo.version}_${timestamp}.drawio`;
      
      // 保存Mermaid文件
      const mermaidFilePath = path.join(this.outputDir, mermaidFileName);
      const mermaidContent = `# ${moduleName} ${diagramType} - Mermaid版本\n\n${description ? `## 描述\n${description}\n\n` : ''}## Mermaid语法\n\n\`\`\`mermaid\n${mermaidSyntax}\n\`\`\``;
      
      await fs.writeFile(mermaidFilePath, mermaidContent, 'utf-8');
      
      // 生成转换指导（MCP不直接生成Draw.io文件）
      const basicGuide = this.generateBasicConversionGuide(mermaidSyntax, diagramType);
      
      return {
        content: [
          {
            type: 'text',
            text: `# Mermaid到Draw.io转换指导\n\n## 已保存Mermaid源文件\n**文件**: \`${mermaidFileName}\`\n**位置**: \`${this.outputDir}/\`\n\n${basicGuide}\n\n## 建议的Draw.io文件名\n\`${drawioFileName}\`\n\n## 🎯 MCP指导原则\n⚠️ **重要**: MCP本身不生成Draw.io文件，只提供转换指导。请根据上述指导，让大模型生成符合规范的Draw.io XML内容。\n\n## 📋 转换任务\n请大模型根据保存的Mermaid语法和上述指导，生成完整的Draw.io XML文件内容，并保存为建议的文件名。\n\n## 验证要求\n- XML格式正确\n- 可在Draw.io中正常打开\n- 符合项目样式规范\n- 保持原有逻辑结构`
          }
        ]
      };
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `转换失败: ${error instanceof Error ? error.message : String(error)}`
          }
        ]
      };
    }
  }

  /**
   * 智能Mermaid到Draw.io转换指导 (核心方法)
   * 
   * 这是最重要的方法，为大语言模型提供完整的转换指导。包含理解确认、
   * 版本管理、动态尺寸计算、样式规范等全套指导内容。
   * 
   * @param mermaidSyntax Mermaid时序图语法
   * @param diagramType 图表类型 (通常为 'sequence')
   * @param moduleName 模块名称，用于文件命名
   * @param description 可选的变更描述，用于版本管理
   * @returns 包含完整转换指导的响应对象
   */
  async convertMermaidToDrawioLLM(mermaidSyntax: string, diagramType: string, moduleName: string, description?: string): Promise<any> {
    try {
      // 确保输出目录存在
      await this.ensureOutputDirectory();
      
      // 智能版本管理：检测是否为重新生成
      const versionInfo = await this.determineVersion(moduleName, diagramType, description);
      
      // 生成文件名
      const timestamp = this.getCurrentDate();
      const mermaidFileName = `${moduleName}_${diagramType}_mermaid_${timestamp}.md`;
      const drawioFileName = `${moduleName}_${diagramType}_${versionInfo.version}_${timestamp}.drawio`;
      
      // 保存Mermaid文件
      const mermaidFilePath = path.join(this.outputDir, mermaidFileName);
      const mermaidContent = `# ${moduleName} ${diagramType} - Mermaid版本\n\n${description ? `## 描述\n${description}\n\n` : ''}## Mermaid语法\n\n\`\`\`mermaid\n${mermaidSyntax}\n\`\`\``;
      
      await fs.writeFile(mermaidFilePath, mermaidContent, 'utf-8');
      
      // 使用大模型智能转换指导（MCP只提供指导，不直接生成Draw.io文件）
      const conversionGuide = this.generateLLMConversionGuide(mermaidSyntax, diagramType, moduleName);
      
      return {
        content: [
          {
            type: 'text',
            text: `# 🚀 智能Mermaid到Draw.io转换指导\n\n## 🧠 第一步：理解确认 (必须完成)\n\n⚠️ **重要提醒**：在开始转换之前，请大模型先完成以下理解确认步骤，以确保不遗漏关键信息：\n\n### 📋 理解确认清单\n请大模型按照自己的理解，用自然语言总结以下内容：\n\n1. **项目背景理解**\n   - 这是什么类型的系统或项目？\n   - 主要的业务场景是什么？\n   - 涉及哪些核心组件或服务？\n\n2. **时序图内容理解**\n   - 这个时序图要展示什么流程？\n   - 有哪些参与者（Actor/Participant）？\n   - 主要的交互步骤是什么？\n   - 是否包含条件分支、循环或异常处理？\n\n3. **关键细节确认**\n   - 是否有自环消息（组件与自己交互）？\n   - 是否需要分组框来组织不同阶段？\n   - 是否有同步和异步消息的区别？\n   - 是否有注释或说明需要特别标注？\n\n4. **完整性检查**\n   - 流程是否有明确的开始和结束？\n   - 是否遗漏了重要的错误处理分支？\n   - 是否需要补充更多的交互细节？\n\n5. **🎯 详细程度要求 (重要)**\n   - **必须详细展示每个步骤**：不能省略中间环节，每个重要操作都要体现\n   - **必须包含错误处理**：正常流程和异常流程都要完整展示\n   - **必须体现数据流转**：明确显示数据在各组件间的传递过程\n   - **必须标注关键节点**：重要的业务逻辑判断点要特别标注\n   - **必须包含循环逻辑**：如果有循环处理，必须用loop框明确标注\n   - **必须显示并发处理**：如果有并行操作，要用par框或分支明确表示\n   - **必须补充业务细节**：不仅要有技术交互，还要体现业务逻辑\n   - **必须标注时间节点**：关键的等待、超时、延迟要明确标注\n\n### ✅ 确认完成标志\n请在理解确认完成后，明确说明：\n- "我已理解项目背景和时序图要求"\n- "我确认已识别所有关键组件和交互"\n- "我准备开始按照MCP规范进行转换"\n\n---\n\n## 📁 版本管理信息\n**当前版本**: ${versionInfo.version}\n**版本类型**: ${versionInfo.isNewVersion ? '🆕 新版本' : '📝 初始版本'}\n${versionInfo.previousVersion ? `**上一版本**: ${versionInfo.previousVersion}` : ''}\n${versionInfo.changeReason ? `**变更原因**: ${versionInfo.changeReason}` : ''}\n\n## 已保存Mermaid源文件\n**文件**: \`${mermaidFileName}\`\n**位置**: \`${this.outputDir}/\`\n\n${conversionGuide}\n\n## 建议的Draw.io文件名\n\`${drawioFileName}\`\n\n## 🎯 MCP指导原则\n⚠️ **重要**: MCP本身不生成Draw.io文件，只提供转换指导。请根据上述分析和指导，让大模型生成符合规范的Draw.io XML内容。\n\n## 📋 样式规范要求 (基于0823版本)\n\n### 参与者样式\n\`\`\`xml\nstyle="rounded=0;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontSize=12;fontStyle=1;"\n\`\`\`\n- 尺寸：120px × 60px，间距：170px\n- 字体：12px 粗体，居中对齐\n\n### 生命线样式\n\`\`\`xml\nstyle="endArrow=none;dashed=1;html=1;strokeColor=#000000;"\n\`\`\`\n- 从参与者底部中心垂直向下\n\n### 消息线样式\n**同步消息**：\n\`\`\`xml\nstyle="endArrow=classic;html=1;strokeColor=#000000;fontSize=10;"\n\`\`\`\n\n**异步消息**：\n\`\`\`xml\nstyle="endArrow=classic;html=1;strokeColor=#000000;dashed=1;fontSize=10;"\n\`\`\`\n\n### ⚠️ 自环消息关键实现\n\`\`\`xml\n<mxCell id="msg_self" value="自环消息" style="endArrow=classic;html=1;strokeColor=#000000;fontSize=10;" edge="1" parent="1">\n  <mxGeometry width="50" height="50" relative="1" as="geometry">\n    <mxPoint x="790" y="480" as="sourcePoint" />\n    <mxPoint x="850" y="480" as="targetPoint" />\n    <Array as="points">\n      <mxPoint x="820" y="480" />\n      <mxPoint x="820" y="500" />\n      <mxPoint x="850" y="500" />\n    </Array>\n  </mxGeometry>\n</mxCell>\n\`\`\`\n\n### 分组框样式 (半透明背景)\n\`\`\`xml\nstyle="rounded=1;whiteSpace=wrap;html=1;fillColor=#f0f8ff;strokeColor=#87ceeb;strokeWidth=2;opacity=30;"\n\`\`\`\n- **关键属性**: opacity=30 (30%透明度)\n- **边框**: strokeWidth=2, rounded=1\n\n### 注释框样式\n\`\`\`xml\nstyle="shape=note;whiteSpace=wrap;html=1;backgroundOutline=1;darkOpacity=0.05;fillColor=#fff2cc;strokeColor=#d6b656;fontSize=11;fontStyle=2;"\n\`\`\`\n\n## 📋 下一步操作\n\n### 🔴 必须先完成：理解确认\n**在开始任何转换工作之前，大模型必须先完成上述"理解确认清单"，并明确表达理解结果。**\n\n### 📝 转换执行步骤\n1. **✅ 理解确认**: 完成项目背景、时序图内容、关键细节和完整性检查\n2. **🔧 大模型任务**: 根据上述Mermaid语法分析和样式规范，生成完整的Draw.io XML内容\n3. **💾 文件保存**: 将生成的XML内容保存为 \`${drawioFileName}\`\n4. **📊 版本管理**: ${versionInfo.isNewVersion ? '新版本将自动记录到CHANGELOG' : '初始版本，建立版本基线'}\n5. **🎨 样式验证**: 确保符合0823版本的样式规范\n6. **✅ 功能验证**: 确保生成的文件可以在Draw.io中正常打开\n\n### ⚠️ 质量保证\n- 如果理解确认发现遗漏或不清楚的地方，请先补充信息再继续\n- 确保生成的图表包含所有必要的组件和交互\n- 验证是否正确处理了自环消息和分组框\n\n## 🔧 转换要求\n- 严格按照0823版本的样式规范\n- 自环消息必须使用<Array as="points">定义弯曲路径\n- 分组框必须使用opacity=30半透明背景\n- 保持Mermaid语法的逻辑结构\n- 确保XML格式正确性\n- ${versionInfo.isNewVersion ? '⚠️ 注意：这是版本更新，请确保改进了之前版本的问题' : ''}`
          }
        ]
      };
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `智能转换准备失败: ${error instanceof Error ? error.message : String(error)}`
          }
        ]
      };
    }
  }

  private generateBasicConversionGuide(mermaidSyntax: string, diagramType: string): string {
    // 为基础转换方法提供简化的指导
    const analysis = this.analyzeMermaidSyntax(mermaidSyntax, diagramType);
    
    return `## 📊 Mermaid语法分析\n\n${analysis.summary}\n\n## 🎨 Draw.io转换要求\n\n### 基础结构\n${analysis.structure}\n\n### 样式规范\n${analysis.styling}\n\n### 布局要求\n${analysis.layout}`;
  }

  private calculateDynamicDimensions(mermaidSyntax: string): {
    pageWidth: number;
    pageHeight: number;
    lifelineHeight: number;
    participantSpacing: number;
    messageSpacing: number;
  } {
    // 分析Mermaid语法以计算所需尺寸
    const lines = mermaidSyntax.split('\n').filter(line => line.trim());
    
    // 计算参与者数量
    const participants = new Set<string>();
    const messages: string[] = [];
    
    lines.forEach(line => {
      const trimmed = line.trim();
      if (trimmed.includes('->') || trimmed.includes('->>') || trimmed.includes('-->>') || trimmed.includes('-->')) {
        messages.push(trimmed);
        // 提取参与者
        const arrowMatch = trimmed.match(/^([^-]+)(-{1,2}>?>?)([^:]+)/);
        if (arrowMatch) {
          participants.add(arrowMatch[1].trim());
          participants.add(arrowMatch[3].split(':')[0].trim());
        }
      } else if (trimmed.startsWith('participant ')) {
        const participant = trimmed.replace('participant ', '').split(' as ')[0].trim();
        participants.add(participant);
      }
    });
    
    const participantCount = Math.max(participants.size, 3); // 最少3个参与者
    const messageCount = Math.max(messages.length, 10); // 最少10条消息，增加基础消息数
    
    // 动态计算尺寸 (基于v1.1版本优化)
    const participantSpacing = 170; // 参与者间距
    const messageSpacing = 50; // 消息间距，从40增加到50
    const topMargin = 200; // 顶部边距
    const bottomMargin = 200; // 底部边距，从100增加到200
    const sideMargin = 100; // 侧边距
    
    // 检测特殊元素，增加额外空间
    let specialElementsBuffer = 0;
    if (mermaidSyntax.includes('loop ')) specialElementsBuffer += 300; // 循环框需要额外空间
    if (mermaidSyntax.includes('alt ') || mermaidSyntax.includes('opt ')) specialElementsBuffer += 200; // 条件框
    if (mermaidSyntax.includes('Note ')) specialElementsBuffer += 100; // 注释框
    
    // 检测自环消息，每个自环需要额外垂直空间
    const selfMessages = this.detectSelfMessages(mermaidSyntax);
    if (selfMessages.length > 0) {
      specialElementsBuffer += selfMessages.length * 30; // 每个自环额外30px
    }
    
    // 计算页面宽度（参与者数量 * 间距 + 边距）
    const pageWidth = Math.max(1800, participantCount * participantSpacing + sideMargin * 2);
    
    // 计算生命线高度（基于v1.1版本的2400px基准）
    const baseLifelineHeight = Math.max(2400, messageCount * messageSpacing + topMargin + bottomMargin + specialElementsBuffer);
    const lifelineHeight = baseLifelineHeight + 300; // 额外300px缓冲，确保充足空间
    
    // 计算页面高度（基于v1.1版本的2500px基准）
    const pageHeight = Math.max(2500, lifelineHeight + 300);
    
    return {
      pageWidth,
      pageHeight,
      lifelineHeight,
      participantSpacing,
      messageSpacing
    };
  }

  private generateLLMConversionGuide(mermaidSyntax: string, diagramType: string, moduleName: string): string {
    // 分析Mermaid语法
    const analysis = this.analyzeMermaidSyntax(mermaidSyntax, diagramType);
    
    // 计算动态尺寸
    const dimensions = this.calculateDynamicDimensions(mermaidSyntax);
    
    return `## 📊 Mermaid语法分析\n\n${analysis.summary}\n\n## 📐 动态尺寸计算 (防止时间线不够)\n\n### 🎯 智能尺寸建议\n基于Mermaid语法分析，推荐以下尺寸设置：\n\n- **页面宽度**: ${dimensions.pageWidth}px\n- **页面高度**: ${dimensions.pageHeight}px  \n- **生命线高度**: ${dimensions.lifelineHeight}px\n- **参与者间距**: ${dimensions.participantSpacing}px\n- **消息间距**: ${dimensions.messageSpacing}px\n\n### ⚠️ 重要提醒\n**避免时间线不够的问题**：\n- 生命线长度必须 ≥ ${dimensions.lifelineHeight}px\n- 页面高度必须 ≥ ${dimensions.pageHeight}px\n- 为复杂流程预留额外200px缓冲空间\n\n### 📏 Draw.io XML配置\n\`\`\`xml\n<mxGraphModel dx="${Math.round(dimensions.pageWidth * 0.9)}" dy="${Math.round(dimensions.pageHeight * 0.75)}" \n             pageWidth="${dimensions.pageWidth}" pageHeight="${dimensions.pageHeight}">\n\`\`\`\n\n### 🔧 生命线配置示例\n\`\`\`xml\n<!-- 生命线必须延伸到足够长度 -->\n<mxCell id="lifeline_example" style="endArrow=none;dashed=1;html=1;strokeColor=#000000;" edge="1" parent="1">\n  <mxGeometry width="50" height="50" relative="1" as="geometry">\n    <mxPoint x="110" y="160" as="sourcePoint" />\n    <mxPoint x="110" y="${dimensions.lifelineHeight}" as="targetPoint" />\n  </mxGeometry>\n</mxCell>\n\`\`\`\n\n### 📊 实际计算结果\n**基于当前Mermaid语法分析**:\n- 检测到参与者数量: ${Math.max(new Set(mermaidSyntax.match(/\\b\\w+(?=\\s*(-{1,2}>?>?|<-{1,2}))/g) || []).size, 3)}\n- 检测到消息数量: ${Math.max((mermaidSyntax.match(/(-{1,2}>?>?|<-{1,2})/g) || []).length, 10)}\n- 特殊元素缓冲: ${(mermaidSyntax.includes('loop ') ? 300 : 0) + (mermaidSyntax.includes('alt ') || mermaidSyntax.includes('opt ') ? 200 : 0) + (mermaidSyntax.includes('Note ') ? 100 : 0)}px\n- **最终生命线高度**: ${dimensions.lifelineHeight}px\n- **最终页面高度**: ${dimensions.pageHeight}px\n\n## 🎨 Draw.io转换指导 (基于0823版本规则)\n\n### 1. 基础结构\n${analysis.structure}\n\n### 2. 样式规范\n${analysis.styling}\n\n### 3. 布局建议\n${analysis.layout}\n\n### 4. 特殊元素处理\n${analysis.specialElements}\n\n## 🔧 转换步骤\n\n1. **设置页面尺寸**: 使用上述计算的动态尺寸\n2. **创建参与者**: 按照${dimensions.participantSpacing}px间距排列\n3. **绘制生命线**: 长度设为${dimensions.lifelineHeight}px\n4. **添加消息**: 按照${dimensions.messageSpacing}px间距排列\n5. **应用0823版本样式规范**\n6. **自环消息使用<Array as="points">定义弯曲路径**\n7. **分组框使用opacity=30半透明背景**\n8. **最终检查**: 确保所有元素在页面范围内`;
  }

  private analyzeMermaidSyntax(mermaidSyntax: string, diagramType: string): any {
    const lines = mermaidSyntax.split('\n').filter(line => line.trim());
    const participants: string[] = [];
    const interactions: string[] = [];
    const elements: string[] = [];
    
    // 分析参与者和交互
    lines.forEach(line => {
      const trimmed = line.trim();
      
      if (trimmed.includes('participant ')) {
        const match = trimmed.match(/participant\s+(\w+)(?:\s+as\s+(.+))?/);
        if (match) {
          participants.push(match[2] || match[1]);
          elements.push('参与者矩形');
        }
      }
      
      if (trimmed.includes('->') || trimmed.includes('-->>') || trimmed.includes('->>')) {
        interactions.push(trimmed);
        elements.push('消息箭头');
      }
    });
    
    return {
      summary: `检测到 ${participants.length} 个参与者，${interactions.length} 个交互`,
      structure: this.getStructureGuide(diagramType, participants, interactions),
      styling: this.getStylingGuide(diagramType),
      layout: this.getLayoutGuide(diagramType, participants.length),
      specialElements: this.getSpecialElementsGuide(mermaidSyntax),
      elements: [...new Set(elements)]
    };
  }

  private getStructureGuide(diagramType: string, participants: string[], interactions: string[]): string {
    switch (diagramType) {
      case 'sequence':
        return `**时序图结构**:
- 顶部放置 ${participants.length} 个参与者矩形
- 每个参与者下方绘制垂直生命线
- 添加 ${interactions.length} 个消息箭头
- 按时间顺序从上到下排列`;
      
      case 'flowchart':
        return `**流程图结构**:
- 识别开始和结束节点
- 确定处理步骤和决策点
- 建立清晰的流程路径`;
      
      default:
        return `**基础结构**: 根据Mermaid语法创建对应的Draw.io元素`;
    }
  }

  private getStylingGuide(diagramType: string): string {
    switch (diagramType) {
      case 'sequence':
        return `**时序图样式** (基于0823版本规则):
- 参与者: 浅蓝色矩形 (#dae8fc)，蓝色边框 (#6c8ebf)，12px粗体
- 生命线: 黑色虚线 (dashed=1)，从参与者中心垂直向下
- 消息箭头: 黑色实线，10px字体，垂直间距30px
- 异步消息: 黑色虚线 (dashed=1)
- 自环消息: 使用Array as="points"定义弯曲路径，向右弯曲后回到生命线
- 分组框: 半透明背景 (opacity=30)，圆角矩形 (rounded=1)，2px边框`;
      
      case 'flowchart':
        return `**流程图样式**:
- 开始/结束: 椭圆形，浅绿色/浅红色
- 处理步骤: 矩形，浅蓝色 (#dae8fc)
- 决策点: 菱形，浅黄色 (#fff2cc)`;
      
      default:
        return `**通用样式**: 应用项目标准颜色和边框规范`;
    }
  }

  private getLayoutGuide(diagramType: string, participantCount: number): string {
    switch (diagramType) {
      case 'sequence':
        return `**时序图布局**:
- 参与者间距: ${Math.max(150, participantCount * 30)}px
- 消息间距: 80px
- 生命线长度: 根据交互数量调整
- 整体宽度: ${participantCount * 200}px`;
      
      default:
        return `**通用布局**: 保持元素间适当间距，确保可读性`;
    }
  }

  private getSpecialElementsGuide(mermaidSyntax: string): string {
    const specialElements: string[] = [];
    
    if (mermaidSyntax.includes('Note ')) {
      specialElements.push('注释框: 使用shape=note样式，黄色背景 (#fff2cc)，金色边框 (#d6b656)');
    }
    
    if (mermaidSyntax.includes('alt ') || mermaidSyntax.includes('opt ')) {
      specialElements.push('🔀 条件框: 半透明背景 (opacity=30)，圆角矩形 (rounded=1)，2px边框');
      specialElements.push(this.getConditionalFrameXML());
    }
    
    if (mermaidSyntax.includes('loop ')) {
      specialElements.push('🔄 循环框: 半透明背景 (opacity=30)，圆角矩形 (rounded=1)，2px边框');
      specialElements.push(this.getLoopFrameXML());
    }
    
    // 检查自环消息
    const selfMessages = this.detectSelfMessages(mermaidSyntax);
    if (selfMessages.length > 0) {
      specialElements.push(`🔄 自环消息 (${selfMessages.length}个): 必须使用curved=1属性和优化的Array路径`);
      specialElements.push(this.getSelfLoopXML());
    }
    
    return specialElements.length > 0 
      ? specialElements.join('\n- ')
      : '无特殊元素需要处理';
  }

  private detectSelfMessages(mermaidSyntax: string): string[] {
    const lines = mermaidSyntax.split('\n').filter(line => line.trim());
    const selfMessages: string[] = [];
    
    lines.forEach(line => {
      const trimmed = line.trim();
      // 检测自环消息模式：A->>A: 或 A-->>A: 等
      const selfMessageMatch = trimmed.match(/(\w+)\s*(->>|-->>|->)\s*\1\s*:/);
      if (selfMessageMatch) {
        selfMessages.push(trimmed);
      }
    });
    
    return selfMessages;
  }

  // 注意：MCP不直接生成Draw.io XML文件，只提供转换指导
  // 以下方法仅作为参考，实际XML生成应由大模型根据MCP指导完成
  
  /*
  private convertMermaidToDrawioXML(mermaidSyntax: string, diagramType: string): string {
    // 此方法已被移除，因为MCP只提供指导，不直接生成Draw.io文件
    // 大模型应根据MCP提供的分析和规范来生成XML内容
    return '';
  }
  */

  /*
  // 以下XML生成方法已被注释，因为MCP只提供指导，不直接生成Draw.io文件
  // 这些方法仅作为参考，帮助理解转换逻辑
  
  private generateSequenceDiagramXML(mermaidSyntax: string): string {
    // 解析Mermaid时序图语法并生成Draw.io XML
    const lines = mermaidSyntax.split('\n').filter(line => line.trim());
    let xml = '';
    let cellId = 2;
    let yPosition = 50;
    const participants: { [key: string]: { id: string, x: number, name: string } } = {};
    let xPosition = 50;

    // 处理参与者
    lines.forEach(line => {
      const trimmed = line.trim();
      const participantMatch = trimmed.match(/participant\s+(\w+)(?:\s+as\s+(.+))?/);
      
      if (participantMatch) {
        const id = participantMatch[1];
        const name = participantMatch[2] || id;
        
        participants[id] = {
          id: `participant_${cellId}`,
          x: xPosition,
          name: name
        };
        
        // 添加参与者矩形
        xml += `        <mxCell id="participant_${cellId}" value="${name}" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
          <mxGeometry x="${xPosition}" y="${yPosition}" width="120" height="60" as="geometry" />
        </mxCell>\n`;
        
        // 添加生命线
        xml += `        <mxCell id="lifeline_${cellId}" value="" style="endArrow=none;dashed=1;html=1;strokeColor=#000000;" edge="1" parent="1">
          <mxGeometry width="50" height="50" relative="1" as="geometry">
            <mxPoint x="${xPosition + 60}" y="${yPosition + 60}" as="sourcePoint" />
            <mxPoint x="${xPosition + 60}" y="600" as="targetPoint" />
          </mxGeometry>
        </mxCell>\n`;
        
        xPosition += 200;
        cellId++;
      }
    });

    // 处理消息
    let messageY = 150;
    lines.forEach(line => {
      const trimmed = line.trim();
      const messageMatch = trimmed.match(/(\w+)\s*(->>|-->>|->)\s*(\w+):\s*(.+)/);
      
      if (messageMatch) {
        const from = messageMatch[1];
        const arrow = messageMatch[2];
        const to = messageMatch[3];
        const message = messageMatch[4];
        
        if (participants[from] && participants[to]) {
          const fromX = participants[from].x + 60;
          const toX = participants[to].x + 60;
          const isAsync = arrow === '-->';
          
          xml += `        <mxCell id="message_${cellId}" value="${message}" style="endArrow=classic;html=1;strokeColor=#000000;${isAsync ? 'dashed=1;' : ''}" edge="1" parent="1">
          <mxGeometry width="50" height="50" relative="1" as="geometry">
            <mxPoint x="${fromX}" y="${messageY}" as="sourcePoint" />
            <mxPoint x="${toX}" y="${messageY}" as="targetPoint" />
          </mxGeometry>
        </mxCell>\n`;
          
          messageY += 80;
          cellId++;
        }
      }
    });

    return xml;
  }

  private generateFlowchartDiagramXML(mermaidSyntax: string): string {
    // 解析Mermaid流程图语法并生成Draw.io XML
    const lines = mermaidSyntax.split('\n').filter(line => line.trim());
    let xml = '';
    let cellId = 2;
    let yPosition = 100;
    const nodes: { [key: string]: { id: string, x: number, y: number, text: string, shape: string } } = {};
    
    // 解析节点和连接
    lines.forEach(line => {
      const trimmed = line.trim();
      
      // 解析节点定义 (如: A[开始])
      const nodeMatch = trimmed.match(/(\w+)\[([^\]]+)\]/);
      if (nodeMatch) {
        const nodeId = nodeMatch[1];
        const nodeText = nodeMatch[2];
        
        nodes[nodeId] = {
          id: `node_${cellId}`,
          x: 200 + (Object.keys(nodes).length * 200),
          y: yPosition,
          text: nodeText,
          shape: 'rectangle'
        };
        
        // 添加节点XML
        xml += `        <mxCell id="node_${cellId}" value="${nodeText}" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
          <mxGeometry x="${nodes[nodeId].x}" y="${nodes[nodeId].y}" width="120" height="60" as="geometry" />
        </mxCell>\n`;
        
        cellId++;
      }
      
      // 解析连接 (如: A --> B)
      const connectionMatch = trimmed.match(/(\w+)\s*-->\s*(\w+)/);
      if (connectionMatch && nodes[connectionMatch[1]] && nodes[connectionMatch[2]]) {
        const fromNode = nodes[connectionMatch[1]];
        const toNode = nodes[connectionMatch[2]];
        
        xml += `        <mxCell id="edge_${cellId}" value="" style="endArrow=classic;html=1;strokeColor=#000000;" edge="1" parent="1" source="${fromNode.id}" target="${toNode.id}">
          <mxGeometry width="50" height="50" relative="1" as="geometry">
            <mxPoint x="${fromNode.x + 60}" y="${fromNode.y + 30}" as="sourcePoint" />
            <mxPoint x="${toNode.x + 60}" y="${toNode.y + 30}" as="targetPoint" />
          </mxGeometry>
        </mxCell>\n`;
        
        cellId++;
      }
    });
    
    // 如果没有解析到节点，添加一个说明
    if (Object.keys(nodes).length === 0) {
      xml = `        <mxCell id="2" value="基于Mermaid语法的${mermaidSyntax.includes('flowchart') ? '流程图' : '图表'}\\n\\n请根据以下Mermaid语法进一步编辑：\\n${mermaidSyntax.substring(0, 100)}..." style="rounded=0;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;align=left;verticalAlign=top;" vertex="1" parent="1">
          <mxGeometry x="100" y="100" width="600" height="200" as="geometry" />
        </mxCell>\n`;
    }
    
    return xml;
  }

  private generateGenericDiagramXML(mermaidSyntax: string, diagramType: string): string {
    // 为其他类型的图表生成基础XML结构
    const diagramTypeMap: { [key: string]: string } = {
      'architecture': '架构图',
      'class': '类图',
      'component': '组件图'
    };
    
    const chineseName = diagramTypeMap[diagramType] || diagramType;
    
    return `        <mxCell id="2" value="基于Mermaid语法的${chineseName}\\n\\n请根据以下Mermaid语法进一步编辑：\\n${mermaidSyntax.substring(0, 150)}..." style="rounded=0;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;align=left;verticalAlign=top;" vertex="1" parent="1">
          <mxGeometry x="100" y="100" width="600" height="250" as="geometry" />
        </mxCell>\n`;
  }
  */

  private async ensureOutputDirectory(): Promise<void> {
    try {
      await fs.access(this.outputDir);
    } catch {
      await fs.mkdir(this.outputDir, { recursive: true });
    }
  }

  private async determineVersion(moduleName: string, diagramType: string, description?: string): Promise<{
    version: string;
    isNewVersion: boolean;
    previousVersion?: string;
    changeReason?: string;
  }> {
    try {
      // 检查是否存在同类型的文件
      const files = await fs.readdir(this.outputDir);
      const pattern = new RegExp(`^${moduleName}_${diagramType}_v(\\d+)\\.(\\d+)_\\d{8}\\.drawio$`);
      
      let latestVersion = null;
      let maxMajor = 0;
      let maxMinor = 0;
      
      // 查找最新版本
      files.forEach(file => {
        const match = file.match(pattern);
        if (match) {
          const major = parseInt(match[1]);
          const minor = parseInt(match[2]);
          
          if (major > maxMajor || (major === maxMajor && minor > maxMinor)) {
            maxMajor = major;
            maxMinor = minor;
            latestVersion = `v${major}.${minor}`;
          }
        }
      });
      
      // 如果没有找到现有版本，返回初始版本
      if (!latestVersion) {
        return {
          version: 'v1.0',
          isNewVersion: false
        };
      }
      
      // 检查是否在同一天已经生成过文件
      const today = this.getCurrentDate();
      const todayPattern = new RegExp(`^${moduleName}_${diagramType}_v\\d+\\.\\d+_${today}\\.drawio$`);
      const todayFiles = files.filter(file => todayPattern.test(file));
      
      if (todayFiles.length > 0) {
        // 同一天重新生成，递增小版本
        const newVersion = `v${maxMajor}.${maxMinor + 1}`;
        return {
          version: newVersion,
          isNewVersion: true,
          previousVersion: latestVersion,
          changeReason: description ? this.analyzeChangeReason(description) : '用户要求重新生成或补充信息'
        };
      }
      
      // 不同天生成，使用现有版本号
      return {
        version: latestVersion,
        isNewVersion: false
      };
      
    } catch (error) {
      // 出错时返回默认版本
      return {
        version: 'v1.0',
        isNewVersion: false
      };
    }
  }

  private analyzeChangeReason(description: string): string {
    const desc = description.toLowerCase();
    
    if (desc.includes('补充') || desc.includes('完善') || desc.includes('添加')) {
      return '补充和完善内容';
    }
    if (desc.includes('修复') || desc.includes('错误') || desc.includes('问题')) {
      return '修复问题或错误';
    }
    if (desc.includes('优化') || desc.includes('改进') || desc.includes('调整')) {
      return '优化和改进';
    }
    if (desc.includes('重构') || desc.includes('重新') || desc.includes('重做')) {
      return '重构或重新设计';
    }
    
    return '内容更新';
  }

  private getCurrentDate(): string {
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, '0');
    const day = String(now.getDate()).padStart(2, '0');
    return `${year}${month}${day}`;
  }

  /**
   * 获取循环框的XML模板
   * 
   * 提供标准的循环框XML结构，包含正确的样式和透明度设置
   */
  private getLoopFrameXML(): string {
    return `
**循环框XML模板**:
\`\`\`xml
<!-- 循环框 - 浅黄色半透明背景 -->
<mxCell id="loop_frame" value="loop [循环条件]" 
       style="rounded=1;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;strokeWidth=2;opacity=30;fontSize=11;fontStyle=2;verticalAlign=top;align=left;" 
       vertex="1" parent="1">
  <mxGeometry x="200" y="300" width="400" height="200" as="geometry" />
</mxCell>
\`\`\`

**关键属性说明**:
- **fillColor=#fff2cc**: 浅黄色背景
- **strokeColor=#d6b656**: 金黄色边框  
- **opacity=30**: 30%透明度 (重要!)
- **strokeWidth=2**: 2px边框宽度
- **rounded=1**: 圆角矩形
- **verticalAlign=top;align=left**: 标签位置在左上角
- **fontSize=11;fontStyle=2**: 11px斜体字体`;
  }

  /**
   * 获取优化的自环消息XML模板
   * 
   * 基于v1.1版本的优化，使用curved=1属性实现更自然的弧形样式
   */
  private getSelfLoopXML(): string {
    return `
**🔄 优化的自环消息XML模板** (基于v1.1版本):
\`\`\`xml
<!-- 自环消息 - 使用弧形样式 -->
<mxCell id="msg_self" value="自环消息内容" 
       style="endArrow=classic;html=1;strokeColor=#000000;fontSize=10;curved=1;" 
       edge="1" parent="1">
  <mxGeometry width="50" height="50" relative="1" as="geometry">
    <mxPoint x="280" y="380" as="sourcePoint" />
    <mxPoint x="280" y="400" as="targetPoint" />
    <Array as="points">
      <mxPoint x="330" y="380" />
      <mxPoint x="330" y="400" />
    </Array>
  </mxGeometry>
</mxCell>
\`\`\`

**🎯 关键优化点**:
- **curved=1**: 启用弧形样式，消除生硬的折线效果
- **优化路径**: 简化Array as="points"定义，只需2个控制点
- **自然弧度**: 向右偏移50px (330-280=50)，创建自然的弧形
- **垂直间距**: 20px的垂直间距，确保弧形美观

**⚠️ 重要提醒**:
- 必须使用 **curved=1** 属性
- sourcePoint和targetPoint的Y坐标要有差异(如380→400)
- 控制点X坐标应比生命线向右偏移40-60px`;
  }

  /**
   * 获取条件框的XML模板
   */
  private getConditionalFrameXML(): string {
    return `
**条件框XML模板**:
\`\`\`xml
<!-- 条件框 - 浅紫色半透明背景 -->
<mxCell id="alt_frame" value="alt [条件]" 
       style="rounded=1;whiteSpace=wrap;html=1;fillColor=#e1d5e7;strokeColor=#9673a6;strokeWidth=2;opacity=30;fontSize=11;fontStyle=2;verticalAlign=top;align=left;" 
       vertex="1" parent="1">
  <mxGeometry x="200" y="300" width="400" height="200" as="geometry" />
</mxCell>
\`\`\`

**关键属性说明**:
- **fillColor=#e1d5e7**: 浅紫色背景
- **strokeColor=#9673a6**: 紫色边框
- **opacity=30**: 30%透明度 (重要!)`;
  }
}
